Delphi Magazine Collection 2001/Delphi Magazine Collection 20001 (2001).iso/DISKS/Issue56/Alfresco/AALstMon.pas

Pascal/Delphi Source File | 2000-03-02 | 5.8 KB | 263 lines

{*********************************************************}
{* AALstMon                                              *}
{* Copyright (c) Julian M Bucknall 1998-2000             *}
{* All rights reserved.                                  *}
{*********************************************************}
{* Algorithms Alfresco Threaded list monitor             *}
{*********************************************************}

{Note: this unit is released as freeware. In other words, you are free
       to use this unit in your own applications, however I retain all
       copyright to the code. JMB}

unit AALstMon;

interface

uses
  SysUtils,
  Classes,
  AAThread;

type
  TaaThreadedList = class
    private
      FList : TList;
      FLock : TaaReadWriteSync;
    protected
      function tlGetItem(aInx : integer) : pointer;
      function tlGetCapacity : integer;
      function tlGetCount : integer;

      procedure tlPutItem(aInx : integer; aItem : pointer);
      procedure tlSetCapacity(aNewCapacity : integer);
      procedure tlSetCount(aNewCount : integer);
    public
      constructor Create;
      destructor Destroy; override;

      function Add(aItem : pointer) : integer;
      procedure Clear; virtual;
      procedure Delete(aInx : integer);
      procedure Exchange(aInx1, aInx2 : integer);
      function Extract(aItem : pointer) : pointer;
      function First : pointer;
      function IndexOf(aItem : pointer) : integer;
      procedure Insert(aInx : integer; aItem : pointer);
      function Last : pointer;
      procedure Move(aCurInx, aNewInx : integer);
      function Remove(aItem : pointer) : integer;
      property Capacity : integer
                  read tlGetCapacity write tlSetCapacity;
      property Count : integer read tlGetCount write tlSetCount;
      property Items[aInx : integer] : pointer
                  read tlGetItem write tlPutItem; default;
  end;

implementation

{===TaaThreadedList==================================================}
constructor TaaThreadedList.Create;
begin
  inherited Create;
  FList := TList.Create;
  FLock := TaaReadWriteSync.Create;
end;
{--------}
destructor TaaThreadedList.Destroy;
begin
  FLock.Free;
  FList.Free;
  inherited Destroy;
end;
{--------}
function TaaThreadedList.Add(aItem : pointer) : integer;
begin
  {Add is a writer}
  FLock.StartWriting;
  try
    Result := FList.Add(aItem);
  finally
    FLock.StopWriting;
  end;
end;
{--------}
procedure TaaThreadedList.Clear;
begin
  {Clear is a writer}
  FLock.StartWriting;
  try
    FList.Clear;
  finally
    FLock.StopWriting;
  end;
end;
{--------}
procedure TaaThreadedList.Delete(aInx : integer);
begin
  {Delete is a writer}
  FLock.StartWriting;
  try
    FList.Delete(aInx);
  finally
    FLock.StopWriting;
  end;
end;
{--------}
procedure TaaThreadedList.Exchange(aInx1, aInx2 : integer);
begin
  {Exchange is a writer}
  FLock.StartWriting;
  try
    FList.Exchange(aInx1, aInx2);
  finally
    FLock.StopWriting;
  end;
end;
{--------}
function TaaThreadedList.Extract(aItem : pointer) : pointer;
begin
  {Extract is a writer}
  FLock.StartWriting;
  try
    Result := FList.Extract(aItem);
  finally
    FLock.StopWriting;
  end;
end;
{--------}
function TaaThreadedList.First : pointer;
begin
  {First is a reader}
  FLock.StartReading;
  try
    Result := FList.First;
  finally
    FLock.StopReading;
  end;
end;
{--------}
function TaaThreadedList.IndexOf(aItem : pointer) : integer;
begin
  {IndexOf is a reader}
  FLock.StartReading;
  try
    Result := FList.IndexOf(aItem);
  finally
    FLock.StopReading;
  end;
end;
{--------}
procedure TaaThreadedList.Insert(aInx : integer; aItem : pointer);
begin
  {Insert is a writer}
  FLock.StartWriting;
  try
    FList.Insert(aInx, aItem);
  finally
    FLock.StopWriting;
  end;
end;
{--------}
function TaaThreadedList.Last : pointer;
begin
  {Last is a reader}
  FLock.StartReading;
  try
    Result := FList.Last;
  finally
    FLock.StopReading;
  end;
end;
{--------}
procedure TaaThreadedList.Move(aCurInx, aNewInx : integer);
begin
  {Move is a writer}
  FLock.StartWriting;
  try
    FList.Move(aCurInx, aNewInx);
  finally
    FLock.StopWriting;
  end;
end;
{--------}
function TaaThreadedList.Remove(aItem : pointer) : integer;
begin
  {Remove is a writer}
  FLock.StartWriting;
  try
    Result := FList.Remove(aItem);
  finally
    FLock.StopWriting;
  end;
end;
{--------}
function TaaThreadedList.tlGetItem(aInx : integer) : pointer;
begin
  {tlGetItem is a reader}
  FLock.StartReading;
  try
    Result := FList[aInx];
  finally
    FLock.StopReading;
  end;
end;
{--------}
function TaaThreadedList.tlGetCapacity : integer;
begin
  {tlGetCapacity is a reader}
  FLock.StartReading;
  try
    Result := FList.Capacity;
  finally
    FLock.StopReading;
  end;
end;
{--------}
function TaaThreadedList.tlGetCount : integer;
begin
  {tlGetCount is a reader}
  FLock.StartReading;
  try
    Result := FList.Count;
  finally
    FLock.StopReading;
  end;
end;
{--------}
procedure TaaThreadedList.tlPutItem(aInx : integer; aItem : pointer);
begin
  {tlPutItem is a writer}
  FLock.StartWriting;
  try
    FList[aInx] := aItem;
  finally
    FLock.StopWriting;
  end;
end;
{--------}
procedure TaaThreadedList.tlSetCapacity(aNewCapacity : integer);
begin
  {tlSetCapacity is a writer}
  FLock.StartWriting;
  try
    FList.Capacity := aNewCapacity;
  finally
    FLock.StopWriting;
  end;
end;
{--------}
procedure TaaThreadedList.tlSetCount(aNewCount : integer);
begin
  {tlSetCount is a writer}
  FLock.StartWriting;
  try
    FList.Count := aNewCount;
  finally
    FLock.StopWriting;
  end;
end;
{====================================================================}

end.